package com.houdoudou.supplier.common;

import java.io.File;
import java.lang.ref.SoftReference;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  


  
import android.app.AlertDialog;
import android.content.Context;
import android.graphics.Bitmap;  
import android.os.Handler;  
import android.os.Message;  
import android.util.Log;  
import android.widget.ImageView;  

public class AsynImageLoader {  
    private static final String TAG = "AsynImageLoader";
    // 这是 FileUtil里面引用了，但是这里没有，我自己加的。
	public static final String CACHE_DIR = "";  
    // 缓存下载过的图片的Map  
    private Map<String, SoftReference<Bitmap>> caches;  
    // 任务队列  
    private List<Task> taskQueue;  
    private boolean isRunning = false;  
    private String localImageFolder;
    private Context context;
    
    public AsynImageLoader(Context context){  
        // 初始化变量  
    	this.context=context;   	
    	System.out.println("       context="+ context);
    	File file= context.getDir("productImages",Context.MODE_PRIVATE );
    	System.out.println("       file="+ file);
    	this.localImageFolder= file.getAbsolutePath();
    	System.out.println("       path="+ this.localImageFolder);
        caches = new HashMap<String, SoftReference<Bitmap>>();  
        taskQueue = new ArrayList<AsynImageLoader.Task>();  
        // 启动图片下载线程  
        isRunning = true;  
        new Thread(runnable).start();  
    }  
      
    /** 
     *  
     * @param imageView 需要延迟加载图片的对象 
     * @param url 图片的URL地址 
     * @param resId 图片加载过程中显示的图片资源 
     */  
    public void showImageAsyn(ImageView imageView, String url, int resId){  
        imageView.setTag(url);  
        Bitmap bitmap = null;
      
         bitmap = loadImageAsyn_Alessio(url, getImageCallback(imageView, resId));  
        
        if(bitmap == null){  
            imageView.setImageResource(resId);  
        }else{  
            imageView.setImageBitmap(bitmap);  
        }  
    }  
      
    public Bitmap loadImageAsyn(String path, ImageCallback callback){  
    	 
        // 判断缓存中是否已经存在该图片  
        if(caches.containsKey(path)){  
            // 取出软引用  
            SoftReference<Bitmap> rf = caches.get(path);  
            // 通过软引用，获取图片  
            Bitmap bitmap = rf.get();  
            // 如果该图片已经被释放，则将该path对应的键从Map中移除掉  
            if(bitmap == null){  
                caches.remove(path);  
            }else{  
                // 如果图片未被释放，直接返回该图片  
                Log.i(TAG, "return image in cache" + path);  
                return bitmap;  
            }  
        }else{  
            // 如果缓存中不常在该图片，则创建图片下载任务  
            Task task = new Task();  
            task.path = path;  
            task.callback = callback;  
            Log.i(TAG, "new Task ," + path);  
            if(!taskQueue.contains(task)){  
                taskQueue.add(task);  
                // 唤醒任务下载队列  
                synchronized (runnable) {  
                    runnable.notify();  
                }  
            }  
        }  
          
        // 缓存中没有图片则返回null  
        return null;  
    }  
    
    
    /*----------自己定义的函数，加入先判断本地是否有图片，没有再从网上下载---------*/
    
    
    public Bitmap loadImageAsyn_Alessio(String path, ImageCallback callback){  
    	boolean needPullFromService=false;
    	boolean needPickFromLocal=false;
    	 Bitmap bitmap=null;
    	 try{
        // 判断缓存中是否已经存在该图片  
        if(!caches.containsKey(path)){  
        	 needPickFromLocal=true;
        	
        }else{  
        	 // 取出软引用  
            SoftReference<Bitmap> rf = caches.get(path);  
            // 通过软引用，获取图片  
            bitmap = rf.get();  
            // 如果该图片已经被释放，则将该path对应的键从Map中移除掉  
            if(bitmap != null){  
            	   // 如果图片未被释放，直接返回该图片  
                Log.i(TAG, "return image in cache" + path);  
                return bitmap;          
            }else{  
            	 caches.remove(path); 
                 needPickFromLocal=true;
                    }  
        }  
         needPickFromLocal=false;   needPullFromService =true; //    这里一直从网上下载。
        if(needPickFromLocal){
        	 String picName = null;            
             String[] nameparse=path.split("\\/");
             for(int i=0;i<nameparse.length;i++){
          	  System.out.println("--"+i+"---"+nameparse[i]); 
             } 
             if (nameparse.length!=9){   
             	new AlertDialog.Builder(context).setTitle("").setMessage("图片名称解析错误").setPositiveButton("确定", null).show();
             	needPullFromService=true;
             }else{
             picName=nameparse[8];   
             System.out.println("--------get LocalBitmap ----------------"+localImageFolder+"/"+picName);
                  bitmap=PicUtil.getLoacalBitmap(localImageFolder+"/"+picName);
                  if(bitmap!=null){   
                	  //存入缓存。
                	  System.out.println("-------------Success--------------");  
                	  caches.put(path, new SoftReference<Bitmap>(bitmap));
                	  return bitmap;
                  }else{needPullFromService=true;
                       System.out.println("-------------Failed--------------"); 
                       }
             }
        }
        
        if(needPullFromService){
        	 // 如果缓存中不常在该图片，则创建图片下载任务  
            Task task = new Task();  
            task.path = path;  
            task.callback = callback;  
            Log.i(TAG, "new Task ," + path);  
            if(!taskQueue.contains(task)){  
                taskQueue.add(task);  
                // 唤醒任务下载队列  
                synchronized (runnable) {  
                    runnable.notify();  
                }  
            }  
        }
    }catch(Exception e){
    	e.printStackTrace();
    }
        // 缓存中没有图片则返回null  
        return null;  
    }  
    /** 
     *  
     * @param imageView  
     * @param resId 图片加载完成前显示的图片资源ID 
     * @return 
     */  
    private ImageCallback getImageCallback(final ImageView imageView, final int resId){  
        return new ImageCallback() {  
              
            @Override  
            public void loadImage(String path, Bitmap bitmap) {  
                if(path.equals(imageView.getTag().toString())){  
                    imageView.setImageBitmap(bitmap);  
                }else{  
                    imageView.setImageResource(resId);  
                }
              /*-------一下由我添加，用于存图片在本地目录--------*/ 
                String picName = null;
            
                String[] nameparse=path.split("\\/");
                for(int i=0;i<nameparse.length;i++){
             	  System.out.println("--"+i+"---"+nameparse[i]); 
                } 
                if (nameparse.length!=9){   
                	new AlertDialog.Builder(context).setTitle("").setMessage("图片名称解析错误").setPositiveButton("确定", null).show();
                }else{
                picName=nameparse[8];              
               boolean result= PicUtil.downpic_alessio(picName, localImageFolder, bitmap);
               System.out.println("--save image to loclal the  file is "+localImageFolder+picName+"------"+String.valueOf(result)); 
                }
               
                
            }  
        };  
    }  
      
    private Handler handler = new Handler(){  
  
        @Override  
        public void handleMessage(Message msg) {  
            // 子线程中返回的下载完成的任务  
            Task task = (Task)msg.obj;  
            // 调用callback对象的loadImage方法，并将图片路径和图片回传给adapter  
            task.callback.loadImage(task.path, task.bitmap);  
        }  
          
    };  
      
    private Runnable runnable = new Runnable() {  
          
        @Override  
        public void run() {  
            while(isRunning){  
                // 当队列中还有未处理的任务时，执行下载任务  
                while(taskQueue.size() > 0){  
                    // 获取第一个任务，并将之从任务队列中删除  
                    Task task = taskQueue.remove(0);  
                    // 将下载的图片添加到缓存  
                    task.bitmap = PicUtil.getbitmap(task.path);  
                    caches.put(task.path, new SoftReference<Bitmap>(task.bitmap));  
                    if(handler != null){  
                        // 创建消息对象，并将完成的任务添加到消息对象中  
                        Message msg = handler.obtainMessage();  
                        msg.obj = task;  
                        // 发送消息回主线程  
                        handler.sendMessage(msg);  
                    }  
                }  
                  
                //如果队列为空,则令线程等待  
                synchronized (this) {  
                    try {  
                        this.wait();  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  
    };  
      
    //回调接口  
    public interface ImageCallback{  
        void loadImage(String path, Bitmap bitmap);  
    }  
      
    class Task{  
        // 下载任务的下载路径  
        String path;  
        // 下载的图片  
        Bitmap bitmap;  
        // 回调对象  
        ImageCallback callback;  
          
        @Override  
        public boolean equals(Object o) {  
            Task task = (Task)o;  
            return task.path.equals(path);  
        }  
    }  
}  
